
using System;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Text;
using ProjectCommon2.Interfaces;


namespace PolePosition.v3.EntityLibrary
{
	// No comments for the class here, all are in Entity.cs.cst
    [DataContract(Namespace = "http://Chfa.DataContracts/2007/10", Name = "VendorDistributionRecloser")]
	public sealed partial class VendorDistributionRecloserEntity
		: Classes.Bases.Entity, ProjectCommon2.Interfaces.ICustomEntity	   
	{
		/// <summary>
		/// Determines if a default value (equivalent to the database's default value) is returned when the value of a <c>null</c> property is requested. 
		/// This makes sure that the stored checksum of a <c>VendorDistributionRecloserEntity</c> with <c>null</c> properties matches the checksum calculated
		/// the next time it is loaded from the database.
		/// </summary>
		/// <remarks>
		/// <para>
		/// This variable exists to solve the checksum discrepancy that arises because the database replaces <c>null</c> values with its own default values
		/// (note that this is only relevant for those Entities for which verifying the checksum is important). An explanation follows.</para>
		///
		/// <para>A <c>VendorDistributionRecloserEntity</c> can contain properties whose values are <c>null</c> (either because they have not been set, or because they were
		/// explicitly set that way). If a <c>VendorDistributionRecloserEntity</c> is persisted to the database in that state, some of the <c>null</c> values will be replaced
		/// with default values by the database. However, before the Entity is persisted to the database, a checksum is calculated for its non-null values, and this
		/// checksum is stored in the database along with the rest of its values in order to validate it next time the Entity is loaded (see how the 
		/// <see cref="CheckSum" /> property works).
		/// </para>
		/// <para>Obviously, the original checksum calculated for an Entity with <c>null</c> properties will differ from the one calculated from its values
		/// the next time it is loaded from the database, since some of the null values were replaced by default values. Performing a checksum test on this Entity
		/// would raise a false <see cref="ProjectCommon2.Exceptions.EntityCheckSumSecurityException" />.
		/// </para>
		/// <para>To avoid this, <c>EnableDefaults</c> should be set to <c>true</c> for those Entities before persisting them to the database. If this is done,
		/// the Entity's column properties do not simply return <c>null</c> if its values are <c>null</c>. Instead, they return a value equivalent to the one the
		/// database would create for the <c>null</c> values (see the documentation for any of the column properties to see how they work). In this way, the
		/// Entity's original checksum, the one stored in the database, is created from the same values that will be used to calculate a checksum the next time 
		/// the Entity is loaded, thus eliminating the checksum discrepancy.
		/// </para>
		/// </remarks>
		public bool EnableDefaults;

		#region " Column Properties "
		
			
			
				
					// Comments
					/// <summary>
					/// Stores the value of the Comments column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Comments</c>),
					/// but through the <see cref="CommentsObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="CommentsObject" /> or the <see cref="Comments" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<string> prop_Comments;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Comments column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Comments column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Comments" /> member or the <see cref="Comments" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Comments" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<string> CommentsObject
					{
						get
						{
							if (prop_Comments == null)
							{
								prop_Comments = new ProjectCommon2.Helpers.PropertyHelper<string>();
							}
							return prop_Comments;
						}
						private set
						{
							prop_Comments = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Comments
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Comments" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="CommentsObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Comments</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Comments corresponds to the database column "tb_Vendor_Distribution_Reclosers.Comments". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: -1.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 0.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.String.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Comments' />.</value>
					[DataMember()]
					public string Comments
					{
						get
						{
							if (EnableDefaults & CommentsObject.IsNull)
							{
								return null;
							}
							return CommentsObject.Value;
						}
						set
						{
							CommentsObject.Value = value;
						}
					}
				
					// CreatedDate
					/// <summary>
					/// Stores the value of the CreatedDate column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>CreatedDate</c>),
					/// but through the <see cref="CreatedDateObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="CreatedDateObject" /> or the <see cref="CreatedDate" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<DateTime?> prop_CreatedDate;
					
					/// <summary>
					/// Gets the helper object that stores the value of the CreatedDate column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the CreatedDate column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_CreatedDate" /> member or the <see cref="CreatedDate" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_CreatedDate" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<DateTime?> CreatedDateObject
					{
						get
						{
							if (prop_CreatedDate == null)
							{
								prop_CreatedDate = new ProjectCommon2.Helpers.PropertyHelper<DateTime?>();
							}
							return prop_CreatedDate;
						}
						private set
						{
							prop_CreatedDate = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the CreatedDate
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_CreatedDate" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="CreatedDateObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_CreatedDate</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// CreatedDate corresponds to the database column "tb_Vendor_Distribution_Reclosers.CreatedDate". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 8.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 23.</item>
					/// <item>Scale: 3.</item>
					/// <item>System type: System.DateTime.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_CreatedDate' />.</value>
					[DataMember()]
					public DateTime? CreatedDate
					{
						get
						{
							if (EnableDefaults & CreatedDateObject.IsNull)
							{
								return null;
							}
							return CreatedDateObject.Value;
						}
						set
						{
							CreatedDateObject.Value = value;
						}
					}
				
					// CurveA
					/// <summary>
					/// Stores the value of the CurveA column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>CurveA</c>),
					/// but through the <see cref="CurveAObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="CurveAObject" /> or the <see cref="CurveA" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_CurveA;
					
					/// <summary>
					/// Gets the helper object that stores the value of the CurveA column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the CurveA column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_CurveA" /> member or the <see cref="CurveA" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_CurveA" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> CurveAObject
					{
						get
						{
							if (prop_CurveA == null)
							{
								prop_CurveA = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_CurveA;
						}
						private set
						{
							prop_CurveA = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the CurveA
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_CurveA" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="CurveAObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_CurveA</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// CurveA corresponds to the database column "tb_Vendor_Distribution_Reclosers.CurveA". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_CurveA' />.</value>
					[DataMember()]
					public int? CurveA
					{
						get
						{
							if (EnableDefaults & CurveAObject.IsNull)
							{
								return null;
							}
							return CurveAObject.Value;
						}
						set
						{
							CurveAObject.Value = value;
						}
					}
				
					// CurveB
					/// <summary>
					/// Stores the value of the CurveB column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>CurveB</c>),
					/// but through the <see cref="CurveBObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="CurveBObject" /> or the <see cref="CurveB" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_CurveB;
					
					/// <summary>
					/// Gets the helper object that stores the value of the CurveB column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the CurveB column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_CurveB" /> member or the <see cref="CurveB" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_CurveB" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> CurveBObject
					{
						get
						{
							if (prop_CurveB == null)
							{
								prop_CurveB = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_CurveB;
						}
						private set
						{
							prop_CurveB = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the CurveB
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_CurveB" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="CurveBObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_CurveB</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// CurveB corresponds to the database column "tb_Vendor_Distribution_Reclosers.CurveB". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_CurveB' />.</value>
					[DataMember()]
					public int? CurveB
					{
						get
						{
							if (EnableDefaults & CurveBObject.IsNull)
							{
								return null;
							}
							return CurveBObject.Value;
						}
						set
						{
							CurveBObject.Value = value;
						}
					}
				
					// CurveC
					/// <summary>
					/// Stores the value of the CurveC column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>CurveC</c>),
					/// but through the <see cref="CurveCObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="CurveCObject" /> or the <see cref="CurveC" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_CurveC;
					
					/// <summary>
					/// Gets the helper object that stores the value of the CurveC column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the CurveC column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_CurveC" /> member or the <see cref="CurveC" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_CurveC" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> CurveCObject
					{
						get
						{
							if (prop_CurveC == null)
							{
								prop_CurveC = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_CurveC;
						}
						private set
						{
							prop_CurveC = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the CurveC
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_CurveC" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="CurveCObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_CurveC</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// CurveC corresponds to the database column "tb_Vendor_Distribution_Reclosers.CurveC". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_CurveC' />.</value>
					[DataMember()]
					public int? CurveC
					{
						get
						{
							if (EnableDefaults & CurveCObject.IsNull)
							{
								return null;
							}
							return CurveCObject.Value;
						}
						set
						{
							CurveCObject.Value = value;
						}
					}
				
					// CurveD
					/// <summary>
					/// Stores the value of the CurveD column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>CurveD</c>),
					/// but through the <see cref="CurveDObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="CurveDObject" /> or the <see cref="CurveD" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_CurveD;
					
					/// <summary>
					/// Gets the helper object that stores the value of the CurveD column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the CurveD column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_CurveD" /> member or the <see cref="CurveD" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_CurveD" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> CurveDObject
					{
						get
						{
							if (prop_CurveD == null)
							{
								prop_CurveD = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_CurveD;
						}
						private set
						{
							prop_CurveD = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the CurveD
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_CurveD" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="CurveDObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_CurveD</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// CurveD corresponds to the database column "tb_Vendor_Distribution_Reclosers.CurveD". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_CurveD' />.</value>
					[DataMember()]
					public int? CurveD
					{
						get
						{
							if (EnableDefaults & CurveDObject.IsNull)
							{
								return null;
							}
							return CurveDObject.Value;
						}
						set
						{
							CurveDObject.Value = value;
						}
					}
				
					// DeterminedByFk
					/// <summary>
					/// Stores the value of the DeterminedByFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>DeterminedByFk</c>),
					/// but through the <see cref="DeterminedByFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="DeterminedByFkObject" /> or the <see cref="DeterminedByFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_DeterminedByFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the DeterminedByFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the DeterminedByFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_DeterminedByFk" /> member or the <see cref="DeterminedByFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_DeterminedByFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> DeterminedByFkObject
					{
						get
						{
							if (prop_DeterminedByFk == null)
							{
								prop_DeterminedByFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_DeterminedByFk;
						}
						private set
						{
							prop_DeterminedByFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the DeterminedByFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_DeterminedByFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="DeterminedByFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_DeterminedByFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// DeterminedByFk corresponds to the database column "tb_Vendor_Distribution_Reclosers.DeterminedByFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_DeterminedByFk' />.</value>
					[DataMember()]
					public int? DeterminedByFk
					{
						get
						{
							if (EnableDefaults & DeterminedByFkObject.IsNull)
							{
								return null;
							}
							return DeterminedByFkObject.Value;
						}
						set
						{
							DeterminedByFkObject.Value = value;
						}
					}
				
					// Interrupter
					/// <summary>
					/// Stores the value of the Interrupter column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Interrupter</c>),
					/// but through the <see cref="InterrupterObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="InterrupterObject" /> or the <see cref="Interrupter" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_Interrupter;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Interrupter column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Interrupter column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Interrupter" /> member or the <see cref="Interrupter" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Interrupter" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> InterrupterObject
					{
						get
						{
							if (prop_Interrupter == null)
							{
								prop_Interrupter = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_Interrupter;
						}
						private set
						{
							prop_Interrupter = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Interrupter
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Interrupter" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="InterrupterObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Interrupter</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Interrupter corresponds to the database column "tb_Vendor_Distribution_Reclosers.Interrupter". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Interrupter' />.</value>
					[DataMember()]
					public int? Interrupter
					{
						get
						{
							if (EnableDefaults & InterrupterObject.IsNull)
							{
								return null;
							}
							return InterrupterObject.Value;
						}
						set
						{
							InterrupterObject.Value = value;
						}
					}
				
					// Latitude
					/// <summary>
					/// Stores the value of the Latitude column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Latitude</c>),
					/// but through the <see cref="LatitudeObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="LatitudeObject" /> or the <see cref="Latitude" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<decimal?> prop_Latitude;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Latitude column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Latitude column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Latitude" /> member or the <see cref="Latitude" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Latitude" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<decimal?> LatitudeObject
					{
						get
						{
							if (prop_Latitude == null)
							{
								prop_Latitude = new ProjectCommon2.Helpers.PropertyHelper<decimal?>();
							}
							return prop_Latitude;
						}
						private set
						{
							prop_Latitude = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Latitude
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Latitude" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="LatitudeObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Latitude</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Latitude corresponds to the database column "tb_Vendor_Distribution_Reclosers.Latitude". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 8.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 53.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Double.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Latitude' />.</value>
					[DataMember()]
					public decimal? Latitude
					{
						get
						{
							if (EnableDefaults & LatitudeObject.IsNull)
							{
								return null;
							}
							return LatitudeObject.Value;
						}
						set
						{
							LatitudeObject.Value = value;
						}
					}
				
					// Longitude
					/// <summary>
					/// Stores the value of the Longitude column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Longitude</c>),
					/// but through the <see cref="LongitudeObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="LongitudeObject" /> or the <see cref="Longitude" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<decimal?> prop_Longitude;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Longitude column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Longitude column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Longitude" /> member or the <see cref="Longitude" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Longitude" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<decimal?> LongitudeObject
					{
						get
						{
							if (prop_Longitude == null)
							{
								prop_Longitude = new ProjectCommon2.Helpers.PropertyHelper<decimal?>();
							}
							return prop_Longitude;
						}
						private set
						{
							prop_Longitude = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Longitude
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Longitude" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="LongitudeObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Longitude</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Longitude corresponds to the database column "tb_Vendor_Distribution_Reclosers.Longitude". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 8.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 53.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Double.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Longitude' />.</value>
					[DataMember()]
					public decimal? Longitude
					{
						get
						{
							if (EnableDefaults & LongitudeObject.IsNull)
							{
								return null;
							}
							return LongitudeObject.Value;
						}
						set
						{
							LongitudeObject.Value = value;
						}
					}
				
					// Manufacturer
					/// <summary>
					/// Stores the value of the Manufacturer column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Manufacturer</c>),
					/// but through the <see cref="ManufacturerObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="ManufacturerObject" /> or the <see cref="Manufacturer" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<string> prop_Manufacturer;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Manufacturer column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Manufacturer column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Manufacturer" /> member or the <see cref="Manufacturer" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Manufacturer" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<string> ManufacturerObject
					{
						get
						{
							if (prop_Manufacturer == null)
							{
								prop_Manufacturer = new ProjectCommon2.Helpers.PropertyHelper<string>();
							}
							return prop_Manufacturer;
						}
						private set
						{
							prop_Manufacturer = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Manufacturer
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Manufacturer" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="ManufacturerObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Manufacturer</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Manufacturer corresponds to the database column "tb_Vendor_Distribution_Reclosers.Manufacturer". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 100.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 0.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.String.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Manufacturer' />.</value>
					[DataMember()]
					public string Manufacturer
					{
						get
						{
							if (EnableDefaults & ManufacturerObject.IsNull)
							{
								return null;
							}
							return ManufacturerObject.Value;
						}
						set
						{
							ManufacturerObject.Value = value;
						}
					}
				
					// ManufDate
					/// <summary>
					/// Stores the value of the ManufDate column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>ManufDate</c>),
					/// but through the <see cref="ManufDateObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="ManufDateObject" /> or the <see cref="ManufDate" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<DateTime?> prop_ManufDate;
					
					/// <summary>
					/// Gets the helper object that stores the value of the ManufDate column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the ManufDate column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_ManufDate" /> member or the <see cref="ManufDate" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_ManufDate" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<DateTime?> ManufDateObject
					{
						get
						{
							if (prop_ManufDate == null)
							{
								prop_ManufDate = new ProjectCommon2.Helpers.PropertyHelper<DateTime?>();
							}
							return prop_ManufDate;
						}
						private set
						{
							prop_ManufDate = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the ManufDate
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_ManufDate" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="ManufDateObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_ManufDate</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// ManufDate corresponds to the database column "tb_Vendor_Distribution_Reclosers.ManufDate". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 8.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 23.</item>
					/// <item>Scale: 3.</item>
					/// <item>System type: System.DateTime.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_ManufDate' />.</value>
					[DataMember()]
					public DateTime? ManufDate
					{
						get
						{
							if (EnableDefaults & ManufDateObject.IsNull)
							{
								return null;
							}
							return ManufDateObject.Value;
						}
						set
						{
							ManufDateObject.Value = value;
						}
					}
				
					// MaxkV
					/// <summary>
					/// Stores the value of the MaxkV column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>MaxkV</c>),
					/// but through the <see cref="MaxkVObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="MaxkVObject" /> or the <see cref="MaxkV" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<string> prop_MaxkV;
					
					/// <summary>
					/// Gets the helper object that stores the value of the MaxkV column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the MaxkV column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_MaxkV" /> member or the <see cref="MaxkV" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_MaxkV" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<string> MaxkVObject
					{
						get
						{
							if (prop_MaxkV == null)
							{
								prop_MaxkV = new ProjectCommon2.Helpers.PropertyHelper<string>();
							}
							return prop_MaxkV;
						}
						private set
						{
							prop_MaxkV = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the MaxkV
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_MaxkV" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="MaxkVObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_MaxkV</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// MaxkV corresponds to the database column "tb_Vendor_Distribution_Reclosers.MaxkV". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 100.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 0.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.String.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_MaxkV' />.</value>
					[DataMember()]
					public string MaxkV
					{
						get
						{
							if (EnableDefaults & MaxkVObject.IsNull)
							{
								return null;
							}
							return MaxkVObject.Value;
						}
						set
						{
							MaxkVObject.Value = value;
						}
					}
				
					// PCBType
					/// <summary>
					/// Stores the value of the PCBType column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>PCBType</c>),
					/// but through the <see cref="PCBTypeObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="PCBTypeObject" /> or the <see cref="PCBType" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_PCBType;
					
					/// <summary>
					/// Gets the helper object that stores the value of the PCBType column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the PCBType column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_PCBType" /> member or the <see cref="PCBType" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_PCBType" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> PCBTypeObject
					{
						get
						{
							if (prop_PCBType == null)
							{
								prop_PCBType = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_PCBType;
						}
						private set
						{
							prop_PCBType = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the PCBType
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_PCBType" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="PCBTypeObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_PCBType</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// PCBType corresponds to the database column "tb_Vendor_Distribution_Reclosers.PCBType". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_PCBType' />.</value>
					[DataMember()]
					public int? PCBType
					{
						get
						{
							if (EnableDefaults & PCBTypeObject.IsNull)
							{
								return null;
							}
							return PCBTypeObject.Value;
						}
						set
						{
							PCBTypeObject.Value = value;
						}
					}
				
					// PhaseFk
					/// <summary>
					/// Stores the value of the PhaseFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>PhaseFk</c>),
					/// but through the <see cref="PhaseFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="PhaseFkObject" /> or the <see cref="PhaseFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_PhaseFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the PhaseFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the PhaseFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_PhaseFk" /> member or the <see cref="PhaseFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_PhaseFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> PhaseFkObject
					{
						get
						{
							if (prop_PhaseFk == null)
							{
								prop_PhaseFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_PhaseFk;
						}
						private set
						{
							prop_PhaseFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the PhaseFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_PhaseFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="PhaseFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_PhaseFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// PhaseFk corresponds to the database column "tb_Vendor_Distribution_Reclosers.PhaseFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  Yes. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_PhaseFk' />.</value>
					[DataMember()]
					public int? PhaseFk
					{
						get
						{
							if (EnableDefaults & PhaseFkObject.IsNull)
							{
								return null;
							}
							return PhaseFkObject.Value;
						}
						set
						{
							PhaseFkObject.Value = value;
						}
					}
				
					// PoleNumber
					/// <summary>
					/// Stores the value of the PoleNumber column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>PoleNumber</c>),
					/// but through the <see cref="PoleNumberObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="PoleNumberObject" /> or the <see cref="PoleNumber" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<string> prop_PoleNumber;
					
					/// <summary>
					/// Gets the helper object that stores the value of the PoleNumber column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the PoleNumber column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_PoleNumber" /> member or the <see cref="PoleNumber" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_PoleNumber" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<string> PoleNumberObject
					{
						get
						{
							if (prop_PoleNumber == null)
							{
								prop_PoleNumber = new ProjectCommon2.Helpers.PropertyHelper<string>();
							}
							return prop_PoleNumber;
						}
						private set
						{
							prop_PoleNumber = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the PoleNumber
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_PoleNumber" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="PoleNumberObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_PoleNumber</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// PoleNumber corresponds to the database column "tb_Vendor_Distribution_Reclosers.PoleNumber". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 100.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 0.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.String.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_PoleNumber' />.</value>
					[DataMember()]
					public string PoleNumber
					{
						get
						{
							if (EnableDefaults & PoleNumberObject.IsNull)
							{
								return null;
							}
							return PoleNumberObject.Value;
						}
						set
						{
							PoleNumberObject.Value = value;
						}
					}
				
					// PPM
					/// <summary>
					/// Stores the value of the PPM column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>PPM</c>),
					/// but through the <see cref="PPMObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="PPMObject" /> or the <see cref="PPM" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<string> prop_PPM;
					
					/// <summary>
					/// Gets the helper object that stores the value of the PPM column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the PPM column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_PPM" /> member or the <see cref="PPM" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_PPM" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<string> PPMObject
					{
						get
						{
							if (prop_PPM == null)
							{
								prop_PPM = new ProjectCommon2.Helpers.PropertyHelper<string>();
							}
							return prop_PPM;
						}
						private set
						{
							prop_PPM = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the PPM
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_PPM" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="PPMObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_PPM</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// PPM corresponds to the database column "tb_Vendor_Distribution_Reclosers.PPM". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 100.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 0.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.String.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_PPM' />.</value>
					[DataMember()]
					public string PPM
					{
						get
						{
							if (EnableDefaults & PPMObject.IsNull)
							{
								return null;
							}
							return PPMObject.Value;
						}
						set
						{
							PPMObject.Value = value;
						}
					}
				
					// Pre1978
					/// <summary>
					/// Stores the value of the Pre1978 column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Pre1978</c>),
					/// but through the <see cref="Pre1978Object" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="Pre1978Object" /> or the <see cref="Pre1978" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<bool?> prop_Pre1978;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Pre1978 column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Pre1978 column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Pre1978" /> member or the <see cref="Pre1978" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Pre1978" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<bool?> Pre1978Object
					{
						get
						{
							if (prop_Pre1978 == null)
							{
								prop_Pre1978 = new ProjectCommon2.Helpers.PropertyHelper<bool?>();
							}
							return prop_Pre1978;
						}
						private set
						{
							prop_Pre1978 = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Pre1978
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Pre1978" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="Pre1978Object" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Pre1978</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Pre1978 corresponds to the database column "tb_Vendor_Distribution_Reclosers.Pre1978". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 1.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 1.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Boolean.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Pre1978' />.</value>
					[DataMember()]
					public bool? Pre1978
					{
						get
						{
							if (EnableDefaults & Pre1978Object.IsNull)
							{
								return null;
							}
							return Pre1978Object.Value;
						}
						set
						{
							Pre1978Object.Value = value;
						}
					}
				
					// SerialNumber
					/// <summary>
					/// Stores the value of the SerialNumber column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>SerialNumber</c>),
					/// but through the <see cref="SerialNumberObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="SerialNumberObject" /> or the <see cref="SerialNumber" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<string> prop_SerialNumber;
					
					/// <summary>
					/// Gets the helper object that stores the value of the SerialNumber column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the SerialNumber column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_SerialNumber" /> member or the <see cref="SerialNumber" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_SerialNumber" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<string> SerialNumberObject
					{
						get
						{
							if (prop_SerialNumber == null)
							{
								prop_SerialNumber = new ProjectCommon2.Helpers.PropertyHelper<string>();
							}
							return prop_SerialNumber;
						}
						private set
						{
							prop_SerialNumber = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the SerialNumber
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_SerialNumber" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="SerialNumberObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_SerialNumber</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// SerialNumber corresponds to the database column "tb_Vendor_Distribution_Reclosers.SerialNumber". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 100.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 0.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.String.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_SerialNumber' />.</value>
					[DataMember()]
					public string SerialNumber
					{
						get
						{
							if (EnableDefaults & SerialNumberObject.IsNull)
							{
								return null;
							}
							return SerialNumberObject.Value;
						}
						set
						{
							SerialNumberObject.Value = value;
						}
					}
				
					// Sticker
					/// <summary>
					/// Stores the value of the Sticker column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Sticker</c>),
					/// but through the <see cref="StickerObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="StickerObject" /> or the <see cref="Sticker" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<bool?> prop_Sticker;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Sticker column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Sticker column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Sticker" /> member or the <see cref="Sticker" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Sticker" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<bool?> StickerObject
					{
						get
						{
							if (prop_Sticker == null)
							{
								prop_Sticker = new ProjectCommon2.Helpers.PropertyHelper<bool?>();
							}
							return prop_Sticker;
						}
						private set
						{
							prop_Sticker = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Sticker
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Sticker" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="StickerObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Sticker</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Sticker corresponds to the database column "tb_Vendor_Distribution_Reclosers.Sticker". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 1.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 1.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Boolean.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Sticker' />.</value>
					[DataMember()]
					public bool? Sticker
					{
						get
						{
							if (EnableDefaults & StickerObject.IsNull)
							{
								return null;
							}
							return StickerObject.Value;
						}
						set
						{
							StickerObject.Value = value;
						}
					}
				
					// TestNo
					/// <summary>
					/// Stores the value of the TestNo column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>TestNo</c>),
					/// but through the <see cref="TestNoObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="TestNoObject" /> or the <see cref="TestNo" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<string> prop_TestNo;
					
					/// <summary>
					/// Gets the helper object that stores the value of the TestNo column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the TestNo column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_TestNo" /> member or the <see cref="TestNo" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_TestNo" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<string> TestNoObject
					{
						get
						{
							if (prop_TestNo == null)
							{
								prop_TestNo = new ProjectCommon2.Helpers.PropertyHelper<string>();
							}
							return prop_TestNo;
						}
						private set
						{
							prop_TestNo = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the TestNo
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_TestNo" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="TestNoObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_TestNo</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// TestNo corresponds to the database column "tb_Vendor_Distribution_Reclosers.TestNo". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 100.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 0.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.String.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_TestNo' />.</value>
					[DataMember()]
					public string TestNo
					{
						get
						{
							if (EnableDefaults & TestNoObject.IsNull)
							{
								return null;
							}
							return TestNoObject.Value;
						}
						set
						{
							TestNoObject.Value = value;
						}
					}
				
					// Type
					/// <summary>
					/// Stores the value of the Type column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Type</c>),
					/// but through the <see cref="TypeObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="TypeObject" /> or the <see cref="Type" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<string> prop_Type;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Type column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Type column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Type" /> member or the <see cref="Type" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Type" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<string> TypeObject
					{
						get
						{
							if (prop_Type == null)
							{
								prop_Type = new ProjectCommon2.Helpers.PropertyHelper<string>();
							}
							return prop_Type;
						}
						private set
						{
							prop_Type = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Type
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Type" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="TypeObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Type</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Type corresponds to the database column "tb_Vendor_Distribution_Reclosers.Type". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 100.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 0.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.String.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Type' />.</value>
					[DataMember()]
					public string Type
					{
						get
						{
							if (EnableDefaults & TypeObject.IsNull)
							{
								return null;
							}
							return TypeObject.Value;
						}
						set
						{
							TypeObject.Value = value;
						}
					}
				
					// Utility_Asset_Reclosers_RecloserFk
					/// <summary>
					/// Stores the value of the Utility_Asset_Reclosers_RecloserFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Utility_Asset_Reclosers_RecloserFk</c>),
					/// but through the <see cref="Utility_Asset_Reclosers_RecloserFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="Utility_Asset_Reclosers_RecloserFkObject" /> or the <see cref="Utility_Asset_Reclosers_RecloserFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_Utility_Asset_Reclosers_RecloserFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Utility_Asset_Reclosers_RecloserFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Utility_Asset_Reclosers_RecloserFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Utility_Asset_Reclosers_RecloserFk" /> member or the <see cref="Utility_Asset_Reclosers_RecloserFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Utility_Asset_Reclosers_RecloserFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> Utility_Asset_Reclosers_RecloserFkObject
					{
						get
						{
							if (prop_Utility_Asset_Reclosers_RecloserFk == null)
							{
								prop_Utility_Asset_Reclosers_RecloserFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_Utility_Asset_Reclosers_RecloserFk;
						}
						private set
						{
							prop_Utility_Asset_Reclosers_RecloserFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Utility_Asset_Reclosers_RecloserFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Utility_Asset_Reclosers_RecloserFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="Utility_Asset_Reclosers_RecloserFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Utility_Asset_Reclosers_RecloserFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Utility_Asset_Reclosers_RecloserFk corresponds to the database column "tb_Vendor_Distribution_Reclosers.Utility_Asset_Reclosers_RecloserFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  Yes. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Utility_Asset_Reclosers_RecloserFk' />.</value>
					[DataMember()]
					public int? Utility_Asset_Reclosers_RecloserFk
					{
						get
						{
							if (EnableDefaults & Utility_Asset_Reclosers_RecloserFkObject.IsNull)
							{
								return null;
							}
							return Utility_Asset_Reclosers_RecloserFkObject.Value;
						}
						set
						{
							Utility_Asset_Reclosers_RecloserFkObject.Value = value;
						}
					}
				
					// Vendor_Distribution_PoleFk
					/// <summary>
					/// Stores the value of the Vendor_Distribution_PoleFk column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Vendor_Distribution_PoleFk</c>),
					/// but through the <see cref="Vendor_Distribution_PoleFkObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="Vendor_Distribution_PoleFkObject" /> or the <see cref="Vendor_Distribution_PoleFk" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_Vendor_Distribution_PoleFk;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Vendor_Distribution_PoleFk column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Vendor_Distribution_PoleFk column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Vendor_Distribution_PoleFk" /> member or the <see cref="Vendor_Distribution_PoleFk" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Vendor_Distribution_PoleFk" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> Vendor_Distribution_PoleFkObject
					{
						get
						{
							if (prop_Vendor_Distribution_PoleFk == null)
							{
								prop_Vendor_Distribution_PoleFk = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_Vendor_Distribution_PoleFk;
						}
						private set
						{
							prop_Vendor_Distribution_PoleFk = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Vendor_Distribution_PoleFk
					/// column.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Vendor_Distribution_PoleFk" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="Vendor_Distribution_PoleFkObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Vendor_Distribution_PoleFk</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Vendor_Distribution_PoleFk corresponds to the database column "tb_Vendor_Distribution_Reclosers.Vendor_Distribution_PoleFk". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  No. </item>
					/// <item>Is primary key:  No. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  No  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  No. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Vendor_Distribution_PoleFk' />.</value>
					[DataMember()]
					public int? Vendor_Distribution_PoleFk
					{
						get
						{
							if (EnableDefaults & Vendor_Distribution_PoleFkObject.IsNull)
							{
								return null;
							}
							return Vendor_Distribution_PoleFkObject.Value;
						}
						set
						{
							Vendor_Distribution_PoleFkObject.Value = value;
						}
					}
				
					// Vendor_Distribution_Reclosers_RecloserId
					/// <summary>
					/// Stores the value of the Vendor_Distribution_Reclosers_RecloserId column.
					/// </summary>
					/// <remarks><para>
					/// This is an instance of the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class, which is
					/// used by all column properties to hold the value assigned to them.
					/// A <c>PropertyHelper</c> object exposes a set of useful properties and behaviors that wouldn't be available if this were a simple 
					/// value-type variable. The properties are dynamic and are used to obtain information about the value contained in the object.
					/// See the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> class for more.</para>
					/// <para>The object is not accessed directly by its corresponding public property (<c>Vendor_Distribution_Reclosers_RecloserId</c>),
					/// but through the <see cref="Vendor_Distribution_Reclosers_RecloserIdObject" /> property. In this way,
					/// there is no need to create the object when the Entity is created, but only until it is needed.
					/// See the <see cref="Vendor_Distribution_Reclosers_RecloserIdObject" /> or the <see cref="Vendor_Distribution_Reclosers_RecloserId" /> properties 
					/// for more.</para>
					/// </remarks>
					private ProjectCommon2.Helpers.PropertyHelper<int?> prop_Vendor_Distribution_Reclosers_RecloserId;
					
					/// <summary>
					/// Gets the helper object that stores the value of the Vendor_Distribution_Reclosers_RecloserId column.
					/// </summary>
					/// <remarks><para>
					/// This intermediary property creates the <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> object for 
					/// the Vendor_Distribution_Reclosers_RecloserId column property if it does not exist yet. It is used to avoid creating the object until it is
					/// needed. This results in a substantial performance gain for Entities with many column properties. See the 
					/// <see cref="prop_Vendor_Distribution_Reclosers_RecloserId" /> member or the <see cref="Vendor_Distribution_Reclosers_RecloserId" />
					/// property for more information about how they work together to provide access to an Entity's column value.
					/// </para></remarks>
					/// <value>Instance of <see cref="ProjectCommon2.Helpers.PropertyHelper&lt;PropertyDataType&gt;" /> contained in 
					/// <see cref="prop_Vendor_Distribution_Reclosers_RecloserId" />.</value>
					[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
					public ProjectCommon2.Helpers.PropertyHelper<int?> Vendor_Distribution_Reclosers_RecloserIdObject
					{
						get
						{
							if (prop_Vendor_Distribution_Reclosers_RecloserId == null)
							{
								prop_Vendor_Distribution_Reclosers_RecloserId = new ProjectCommon2.Helpers.PropertyHelper<int?>();
							}
							return prop_Vendor_Distribution_Reclosers_RecloserId;
						}
						private set
						{
							prop_Vendor_Distribution_Reclosers_RecloserId = value;
						}	
					}
					
					/// <summary>
					/// Gets or Sets the value of the Vendor_Distribution_Reclosers_RecloserId
					/// column, which is (part of) the Primary Key of the VendorDistributionRecloser table.
					/// </summary>
					/// <remarks>
					/// <para>The Get accessor returns the current value assigned to this property, except when it is <c>null</c> (i.e., no value has been
					/// assigned). In that case, the value returned depends on the value of the Entity's <see cref="EnableDefaults" /> member. If it is <c>false</c>, the accessor
					/// simply returns <c>null</c>. However, when <see cref="EnableDefaults" /> is <c>true</c>, it returns the database's default value for the column that 
					/// corresponds to this property. To find out what the default value is, see the list of characteristics for the column at the end of this page. If there
					/// is no default value for the column, then <c>null</c> is returned. For more information about why this is done, see the documentation for 
					/// <see cref="EnableDefaults" />.
					/// </para>
					/// <para>When setting a value for this property, the Set accessor stores the given value in 
					/// <see cref="prop_Vendor_Distribution_Reclosers_RecloserId" /> (a helper object), but this property does not access it directly. Instead,
					/// it uses <see cref="Vendor_Distribution_Reclosers_RecloserIdObject" />, which is a read-only property that returns a reference to the 
					/// <c>prop_Vendor_Distribution_Reclosers_RecloserId</c> helper object.
					/// </para>
					/// <para>In other words, there are two properties and one object for every column value that needs to be stored in the Entity. The intermediary read-only 
					/// property exists to make sure that the helper object is only instantiated when and if needed, which results in performance benefits for Entities with 
					/// many column properties.
					/// </para>
					/// Vendor_Distribution_Reclosers_RecloserId corresponds to the database column "tb_Vendor_Distribution_Reclosers.Vendor_Distribution_Reclosers_RecloserId". The following are 
					/// characteristics of this column:
					/// <list type="bullet">
					/// <item>Length/Size: 4.</item>
					/// <item>Allows null:  No. </item>
					/// <item>Is primary key:  Yes. </item>
					/// <item>Is foreign key:  No. </item>
					/// <item>Is unique:  Yes  (does not reflect ad hoc unique indexes).</item>
					/// <item>Is identity:  Yes. </item>
					/// <item>Precision: 10.</item>
					/// <item>Scale: 0.</item>
					/// <item>System type: System.Int32.</item>
					/// <item>Default value:  None. </item>
					/// </list>
					/// </remarks>
					/// <value>Value stored in <see cref='prop_Vendor_Distribution_Reclosers_RecloserId' />.</value>
					[DataMember()]
					public int? Vendor_Distribution_Reclosers_RecloserId
					{
						get
						{
							if (EnableDefaults & Vendor_Distribution_Reclosers_RecloserIdObject.IsNull)
							{
								return null;
							}
							return Vendor_Distribution_Reclosers_RecloserIdObject.Value;
						}
						set
						{
							Vendor_Distribution_Reclosers_RecloserIdObject.Value = value;
						}
					}

			// Special: FriendlyName
			/// <summary>
			///	Stores the value of the FriendlyName column.
			/// </summary>
			/// <value>Human-readable form of <c>VendorDistributionRecloserEntity</c>'s name.</value>
			private string prop_FriendlyName;

			/// <summary>
			/// Gets or Sets a value that contains a more descriptive, human-readable form of <c>VendorDistributionRecloserEntity</c>'s name.
			/// </summary>
			/// <value>Human-readable form of <c>VendorDistributionRecloserEntity</c>'s name.</value>
			/// <remarks>Although <c>Set</c> is available, this value is never written back to the database. It is 
			/// made up from other columns in the database by the stored procedure that retrieves <c>VendorDistributionRecloserEntity</c>'s
			/// record from the database.</remarks>
			[DataMember()]
			public string FriendlyName
			{
				get
				{
					return prop_FriendlyName;
				}
				set
				{
					prop_FriendlyName = value;
				}
			}
			
		#endregion

		#region " Other Properties "
		
		/// <summary>
		/// Stores a manually set value that indicates if <c>VendorDistributionRecloserEntity</c>'s data is new.
		/// </summary>
		/// <remarks>
		/// Normally, this field should stay <c>null</c> to let <see cref="IsNew" />'s logic
		/// decide whether to return <c>true</c> or <c>false</c>.
		/// </remarks>
		private bool? prop_IsNew;
		
		/// <summary>
		/// Gets or Sets a value that specifies whether <c>VendorDistributionRecloserEntity</c> contains new VendorDistributionRecloser data
		/// or data loaded from an existing VendorDistributionRecloser record.
		/// <para> </para>
		/// <c>True</c> if the data is new; <c>false</c> if it is from an existing record.
		/// </summary>
		/// <remarks>
		/// <para>Provided that its associated field (<see cref="prop_IsNew" />) stays <c>null</c>, this property returns
		/// <c>true</c> if no Primary Key value exists for <c>VendorDistributionRecloserEntity</c>; false if there is one. This determines
		/// if a persist command (calling VendorDistributionRecloserFactory's <c>Save()</c> method) will cause an <c>INSERT</c> or an
		/// <c>UPDATE</c> in the database. For more information, see how
		/// <see cref="Classes.Factories.VendorDistributionRecloserFactory.Save(Classes.Entities.VendorDistributionRecloserEntity, bool)" /> works.
		/// </para>
		/// <para>Note that manually setting this property's value to something other than <c>null</c> will bypass its logic,
		/// and it will return whatever value it is set to, even if it is incorrect.</para>
		/// </remarks>
		/// <value>Indicates if <c>VendorDistributionRecloserEntity</c>'s data is new. Can be set to <c>true</c> (to indicate new data), <c>false</c>, 
		/// or <c>null</c>.</value>
		[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
		public bool? IsNew
		{
			get
			{
				// support manually overriding the IsNew value
				if (prop_IsNew != null)
				{
                    return prop_IsNew;
				}
                // Check IsDirty of key only
                return (this.Vendor_Distribution_Reclosers_RecloserIdObject.IsNull);
			}
			set
			{
				// manually override IsNew
				prop_IsNew = value;
			}
		}
		
		/// <summary>
		/// Stores a value that indicates whether <c>VendorDistributionRecloserEntity</c> has been modified.
		/// </summary>
		/// <remarks>
		/// Normally, this field should stay <c>null</c> to let <see cref="IsDirty" />'s logic
		/// decide whether to return <c>true</c> or <c>false</c>.
		/// </remarks>
		private bool? prop_IsDirty;
		
		/// <summary>
		/// Gets a value that specifies whether <c>VendorDistributionRecloserEntity</c>'s data has been modified since it was first loaded, or
		/// since the last time its <c>AcceptChanges()</c> method was called.
		/// <para> </para>
		/// <c>True</c> if the Entity has changed; <c>false</c> if it has not.
		/// </summary>
		/// <remarks>
		/// <para>Provided that its associated field (<see cref="prop_IsDirty" />) stays <c>null</c>, it returns <c>true</c> if
		/// the Entity's <see cref="IsNew" /> or <see cref="IsMarkedToDelete" /> properties are <c>true</c>. If none of them is, 
		/// it will check whether its <see cref="CheckSum" /> has changed and return an appropiate value based on the result of 
		/// that check.</para>
		/// <para>The value returned by <c>IsDirty</c> determines if a persist command (calling VendorDistributionRecloserFactory's <c>Save()</c>)
		/// will <c>UPDATE</c> the corresponding record in the database. For more information, see how
		/// <see cref="Classes.Factories.VendorDistributionRecloserFactory.Save(Classes.Entities.VendorDistributionRecloserEntity, bool)" /> works.
		/// </para>
		/// <para>Note that manually setting this property's value to something other than <c>null</c> will bypass its logic,
		/// and it will return whatever value it is set to, even if it is incorrect.</para>
		/// </remarks>
		/// <value><c>Indicates if VendorDistributionRecloserEntity</c> has been modified. <c>True</c> if it has; <c>false</c> otherwise.</value>
		[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
		public bool? IsDirty
		{
			get
			{
				
				// support manually overriding the IsDirty value
				if (prop_IsDirty != null)
				{
                    return prop_IsDirty;
				}

				if (IsNew == true)
					return true;
					
				if (IsMarkedToDelete == true)
					return true;
				
				if (CheckSumOriginal != CheckSum)
					return true;
					
				return RecurseBooleanProperty(this, "IsDirty");
			}
			private set
			{
				//only set the variable if manually set. Set is only available for serialization and should
				//only be used for reconstruction by deserialization.
				if (m_IsDirtyManuallySet)
					prop_IsDirty = value;
			}
		}
		
		//private variable supplied for deserialization, so that if the IsDirty was set manually the
		//prop_IsDirty can be set on reconstruction
		private bool m_IsDirtyManuallySet;
		
		/// <summary>
		/// Sets a value that indicates whether <c>VendorDistributionRecloserEntity</c> has changed.
		/// <para> </para>
		/// Use <c>true</c> if the Entity has changed, <c>false</c> if not, or <c>null</c> to let
		/// the <see cref="IsDirty" /> property determine an appropiate value.
		/// </summary>
		/// <remarks>If set to something other than <c>null</c>, this overrides the <see cref="IsDirty" /> property's logic so that it will return the assigned
		/// value even if it is incorrect.</remarks>
		/// <value><c>Indicates if VendorDistributionRecloserEntity</c> has been modified. <c>True</c> if it has; <c>false</c> otherwise.</value>
		public void SetManualIsDirty(bool? value)
		{
			// manually override IsDirty
			prop_IsDirty = value;
			
			if (value == null)
				m_IsDirtyManuallySet = false;
			else
				m_IsDirtyManuallySet = true;
			
		}

		/// <summary>
		/// Stores a value that indicates whether the <c>VendorDistributionRecloserEntity</c> is to be deleted.
		/// </summary>
		private bool prop_IsMarkedToDelete;
		
		/// <summary>
		/// Gets or Sets a value that specifies whether <c>VendorDistributionRecloserEntity</c>'s data is to be removed from the database.
		/// <para> </para>
		/// <c>True</c> deletes the VendorDistributionRecloser data.
		/// </summary>
		/// <remarks>Determines if a persist command (calling VendorDistributionRecloserFactory's <c>Save()</c>) will DELETE the Entity's
		/// corresponding record in the database. For more information, see how
		/// <see cref="Classes.Factories.VendorDistributionRecloserFactory.Save(Classes.Entities.VendorDistributionRecloserEntity, bool)" /> works.
		/// </remarks>
		/// <value><c>VendorDistributionRecloserEntity</c>'s deletion mark. <c>True</c> to delete; <c>false</c> otherwise.</value>
		[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
		public bool IsMarkedToDelete
		{
			get
			{
				return prop_IsMarkedToDelete;
			}
			set
			{
				prop_IsMarkedToDelete = value;
			}
		}

		/// <summary>
		/// Gets a unique checksum for <c>VendorDistributionRecloserEntity</c>, calculated from its current property values.
		/// </summary>
		/// <remarks>
		/// <para>This property creates a checksum for <c>VendorDistributionRecloserEntity</c>'s values by calling
		/// <see cref="PolePosition.v3.EntityLibrary.Entity.MakeHash" />, and sending it every column property's values, except for Checksum,
		/// the Primary Key, and any <c>null</c> properties.
		///</para>
		/// <para>The checksum is stored in the database along with the rest of <c>VendorDistributionRecloserEntity</c>'s values when it is
		/// created or modified. Then, whenever <c>VendorDistributionRecloserEntity</c> is loaded from the database, a new checksum is calculated
		/// on the loaded values and compared to the stored checksum (see <see cref="LoadFromDataRow(System.Data.DataRow, bool)" />).
		/// Because the checksum is unique for a specified set of values, if the database values were modified by someone without proper
		/// authorization, the checksums will not match, and an <see cref="ProjectCommon2.Exceptions.EntityCheckSumSecurityException" />
		/// will be thrown.
		/// </para>
		/// </remarks>
		/// <value>String that uniquely identifies the contents of the Entity it belongs to.</value>
		[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
		public string CheckSum
		{
			get
			{
				System.Text.StringBuilder sb = new System.Text.StringBuilder();
				if (this.Vendor_Distribution_PoleFk != null) { sb.Append(this.Vendor_Distribution_PoleFk.ToString()); }
				if (this.Utility_Asset_Reclosers_RecloserFk != null) { sb.Append(this.Utility_Asset_Reclosers_RecloserFk.ToString()); }
				if (this.Latitude != null) { sb.Append(this.Latitude.ToString()); }
				if (this.Longitude != null) { sb.Append(this.Longitude.ToString()); }
				if (this.CreatedDate != null) { sb.Append(this.CreatedDate.ToString()); }
				if (this.Manufacturer != null) { sb.Append(this.Manufacturer.ToString()); }
				if (this.SerialNumber != null) { sb.Append(this.SerialNumber.ToString()); }
				if (this.ManufDate != null) { sb.Append(this.ManufDate.ToString()); }
				if (this.PoleNumber != null) { sb.Append(this.PoleNumber.ToString()); }
				if (this.PhaseFk != null) { sb.Append(this.PhaseFk.ToString()); }
				if (this.MaxkV != null) { sb.Append(this.MaxkV.ToString()); }
				if (this.Type != null) { sb.Append(this.Type.ToString()); }
				if (this.CurveA != null) { sb.Append(this.CurveA.ToString()); }
				if (this.CurveB != null) { sb.Append(this.CurveB.ToString()); }
				if (this.CurveC != null) { sb.Append(this.CurveC.ToString()); }
				if (this.CurveD != null) { sb.Append(this.CurveD.ToString()); }
				if (this.Interrupter != null) { sb.Append(this.Interrupter.ToString()); }
				if (this.Pre1978 != null) { sb.Append(this.Pre1978.ToString()); }
				if (this.PCBType != null) { sb.Append(this.PCBType.ToString()); }
				if (this.PPM != null) { sb.Append(this.PPM.ToString()); }
				if (this.DeterminedByFk != null) { sb.Append(this.DeterminedByFk.ToString()); }
				if (this.TestNo != null) { sb.Append(this.TestNo.ToString()); }
				if (this.Sticker != null) { sb.Append(this.Sticker.ToString()); }
				if (this.Comments != null) { sb.Append(this.Comments.ToString()); }
				
				return MakeHash(sb.ToString());
			}
			private set
			{
					//Intentionally not implimented. Set is only available for serialization.
					//Due to reconstruction of the object upon deserialization in WCF this set
					//is called regardless of whether it is private. For this reason the method
					//contains no code nor a NotImplemented exception.
			}
		}
		
		/// <summary>
		/// Stores the string that represents the original checksum for <c>VendorDistributionRecloserEntity</c>.
		/// </summary>
		private string prop_CheckSumOriginal = string.Empty;
		/// <summary>
		/// Gets or Sets the original checksum loaded from the database when <c>VendorDistributionRecloserEntity</c> was first constructed.
		/// </summary>
		/// <remarks>Stored so that its value can be compared to the checksum in the database record when writing <c>VendorDistributionRecloserEntity</c> 
		/// back to the database. When checksum verification is used, this comparison makes sure that <c>VendorDistributionRecloserFactory</c> is writing to the correct, 
		/// and unmodified, record from which <c>VendorDistributionRecloserEntity</c> was created.
		/// </remarks>
		/// <value>Original checksum value loaded from the database for <c>VendorDistributionRecloserEntity</c>.</value>
		[DataMember(), System.ComponentModel.Bindable(false), System.ComponentModel.Browsable(false)]
		public string CheckSumOriginal
		{
			get
			{
				return prop_CheckSumOriginal;
			}
			set
			{
				prop_CheckSumOriginal = value;
			}
		}
		#endregion
		
	}
}

